package es.wtestgen.action.profesor;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionRedirect;

import es.wtestgen.action.WTestGenAction;
import es.wtestgen.bean.profesor.AlumnoForm;
import es.wtestgen.bean.profesor.NotaForm;
import es.wtestgen.domain.Alumno;
import es.wtestgen.domain.Asignatura;
import es.wtestgen.domain.Examen;
import es.wtestgen.domain.ExamenResuelto;
import es.wtestgen.domain.Profesor;
import es.wtestgen.services.AlumnoDAO;
import es.wtestgen.services.AsignaturaDAO;
import es.wtestgen.services.ExamenDAO;
import es.wtestgen.services.ExamenResueltoDAO;
import es.wtestgen.services.WTestGenService;
import es.wtestgen.util.DniDuplicadoException;
import es.wtestgen.util.HibernateUtil;
import es.wtestgen.util.NombreUsuaException;

public class MantenimientoNotasAction extends WTestGenAction {
	
	private static final Log log = LogFactory.getLog(MantenimientoNotasAction.class);

	@Override
	public ActionForward _execute(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response) throws NombreUsuaException, DniDuplicadoException  {

		//String forward = "error";	
		
		log.info("_________Estamos en MantenimientoNotasAction, donde se gestionan los tramites sobre las notas por parte del profesor");	
		String accion = request.getParameter("accion");
		ActionForward forward = null;
		
		if(accion == null || accion.equals("")){
			forward = listar(mapping, form, request, response);
		}else if(accion.equals("notasPorAlumno")){
			forward = notasPorAlumno(mapping, form, request, response);			
		}else if(accion.equals("notasPorAsignatura")){
			forward = notasPorAsignatura(mapping, form, request, response);
		}else if(accion.equals("notasPorExamen")){
			forward = notasPorExamen(mapping, form, request, response);		
		}else if(accion.equals("notasExamenesPorAlumnoAsignatura")){
			forward = notasExamenesPorAlumnoAsignatura(mapping, form, request, response);
		}
		
		return forward;
	}

	private ActionForward notasExamenesPorAlumnoAsignatura(ActionMapping mapping,
			ActionForm form, HttpServletRequest request,
			HttpServletResponse response) {
		Profesor profesor = (Profesor)request.getSession().getAttribute("usuario");
		
		NotaForm notaForm = (NotaForm)form;		
		
		AlumnoDAO alumnoDao = new AlumnoDAO();
		ExamenDAO examenDao = new ExamenDAO();
		AsignaturaDAO asignaturaDao = new AsignaturaDAO();			
		ExamenResueltoDAO examenResueltoDao = new ExamenResueltoDAO();
		
		ExamenResuelto examenResuelto = new ExamenResuelto();
		Examen examen = new Examen();
		Asignatura asignatura =  new Asignatura();
		Alumno alumno = new Alumno();
		
		String codAlum = (String)request.getParameter("codAlum");
		String codAsig = (String)request.getParameter("codAsig");
		
		if(codAlum != null && !"".equals(codAlum)){
			alumno = (Alumno)alumnoDao.findById(codAlum).get(0);	
		}
		if(codAsig != null && !"".equals(codAsig)){
			asignatura = (Asignatura)asignaturaDao.findById(codAsig).get(0);
		}
					
		List<Examen> examenes = examenDao.findByAsignatura(asignatura);
					
		List<ExamenResuelto> examenesResueltos = new ArrayList<ExamenResuelto>();

		examenesResueltos = examenResueltoDao.findByExamenYAlumno(examen, alumno);
		
		Map<String, String> notasAlumno = new HashMap<String, String>();
		
		Map<String, String> examenesAlumno = new HashMap<String, String>();
		
		
		for (Iterator iterator = examenes.iterator(); iterator.hasNext();) {
			Examen exam = (Examen) iterator.next();
			
			for (Iterator iterator2 = examenesResueltos.iterator(); iterator2
					.hasNext();) {
				ExamenResuelto examResu = (ExamenResuelto) iterator2.next();
				
				if(exam.getCodExam() == examResu.getExamen().getCodExam()){
					notasAlumno.put(String.valueOf(exam.getCodExam()), String.valueOf(examResu.getNota()));
				}else{
					notasAlumno.put(String.valueOf(exam.getCodExam()), "Pendiente");			
				}
				
			}
							
		}
			
		
		request.getSession().setAttribute("asignatura", asignatura);		
		request.getSession().setAttribute("alumno", alumno);		
		request.getSession().setAttribute("examenes", examenes);		
		request.getSession().setAttribute("notasAlumno", notasAlumno);
		
		return mapping.findForward("verNotasExamenesPorAlumnoAsignatura");
	}

	private ActionForward notasPorExamen(ActionMapping mapping,
			ActionForm form, HttpServletRequest request,
			HttpServletResponse response) {

			Profesor profesor = (Profesor)request.getSession().getAttribute("usuario");
			
			NotaForm notaForm = (NotaForm)form;		
			
			AlumnoDAO alumnoDao = new AlumnoDAO();
			ExamenDAO examenDao = new ExamenDAO();
			AsignaturaDAO asignaturaDao = new AsignaturaDAO();			
			ExamenResueltoDAO examenResueltoDao = new ExamenResueltoDAO();
			
			ExamenResuelto examenResuelto = new ExamenResuelto();
			Examen examen = new Examen();
			Asignatura asignatura =  new Asignatura(); 
			
			String codExam = (String)request.getParameter("codExam");
			
			if(codExam != null && !"".equals(codExam)){
				examen = (Examen)examenDao.findById(codExam).get(0);	
			}
						
			//asignatura = examen.getAsignatura();
			
			asignatura = examenDao.getAsignatura(codExam);
			
			Set<Alumno> alumnos = new HashSet<Alumno>(); 
			//Set<Alumno> alumnos = asignatura.getAlumnos();
			
			alumnos = (Set<Alumno>)alumnoDao.findAlumnosAsignatura(asignatura);
					
			List<ExamenResuelto> examenesResueltos = new ArrayList<ExamenResuelto>();

			Map<String, String> notasAlumno = new HashMap<String, String>();
			
			Map<String, Integer> numExamenesPropuestos = new HashMap<String, Integer>();
			Map<String, Integer> numExamenesResueltos = new HashMap<String, Integer>();
			
			
			for (Iterator iterator = alumnos.iterator(); iterator.hasNext();) {
				Alumno alumno = (Alumno) iterator.next();
				examenesResueltos = examenResueltoDao.findByExamenYAlumno(examen, alumno);
				if(examenesResueltos != null && examenesResueltos.size() > 0){
					examenResuelto = examenesResueltos.get(0);
					
					notasAlumno.put(String.valueOf(alumno.getCodAlum()), String.valueOf(examenResuelto.getNota()));
				}else{
					notasAlumno.put(String.valueOf(alumno.getCodAlum()), "Pendiente");
				}		
				
				examenesResueltos = new ArrayList<ExamenResuelto>();				
			}
				
			
			//request.getSession().setAttribute("alumno", alumno);
			//request.getSession().setAttribute("asignaturas", asignaturas);
			
			request.getSession().setAttribute("alumnos", alumnos);		
			request.getSession().setAttribute("notasAlumno", notasAlumno);
			request.getSession().setAttribute("examen", examen);
			
			//request.getSession().setAttribute("numExamenesResueltos", numExamenesResueltos);
			//request.getSession().setAttribute("numExamenesPropuestos", numExamenesPropuestos);
			
			return mapping.findForward("verNotasPorExamen");
	}

	/**
	 * Calcula la nota media de la asignatura basándose en las notas medias de los alumnos divida por todos los alumnos
	 * de forma que no tiene en cuenta si quedan examenes por resolver por algunos alumnos
	 * @param mapping
	 * @param form
	 * @param request
	 * @param response
	 * @return
	 */
	
	private ActionForward notasPorAsignatura(ActionMapping mapping,
			ActionForm form, HttpServletRequest request,
			HttpServletResponse response) {
		
		Profesor profesor = (Profesor)request.getSession().getAttribute("usuario");
		
		NotaForm notaForm = (NotaForm)form;
		
		double notaMedia = 0.0d;
		double notaMediaAsignatura = 0.0d;
		
		int numExam = 0;
		int resueltos = 0;
		
		ExamenDAO examenDao = new ExamenDAO();
		ExamenResueltoDAO examenResueltoDao = new ExamenResueltoDAO();
		AsignaturaDAO asignaturaDao = new AsignaturaDAO();
		AlumnoDAO alumnoDao = new AlumnoDAO();
		
		Set<Alumno> alumnos = new HashSet<Alumno>();
		
		Asignatura asignatura =  (Asignatura)asignaturaDao.findById(notaForm.getCodAsig()).get(0);
		
		ExamenResuelto examenResuelto = new ExamenResuelto();
		
		List<Examen> examenes = (List<Examen>)examenDao.findByAsignatura(asignatura);
		List<ExamenResuelto> examenesResueltos = new ArrayList<ExamenResuelto>();		
		
		Map<String, String> notasAlumnos = new HashMap<String, String>();
		Map<String, String> numExamenesResueltos = new HashMap<String, String>();
		
		alumnos = alumnoDao.findAlumnosAsignatura(asignatura);
		
		for (Iterator iterator = alumnos.iterator(); iterator.hasNext();) {
			Alumno alumno = (Alumno) iterator.next();
						
			for (Iterator iterator3 = examenes.iterator(); iterator3.hasNext();) {
				Examen examen = (Examen) iterator3.next();			
				if(examenResueltoDao.findByExamenYAlumno(examen,alumno).size() > 0){
					examenResuelto = (ExamenResuelto)examenResueltoDao.findByExamenYAlumno(examen,alumno).get(0);
					examenesResueltos.add(examenResuelto);
					notaMedia = examenResuelto.getNota() + notaMedia;
					numExam++;
					resueltos++;
				}			
			}		
			if(numExam > 0){
				notaMedia = (double)Math.round((notaMedia / numExam)*100)/100;
				notaMediaAsignatura = notaMediaAsignatura + notaMedia;
			}else{
				notaMedia = 0.0d;
			}
			
			numExamenesResueltos.put(String.valueOf(alumno.getCodAlum()), String.valueOf(resueltos));
			notasAlumnos.put(String.valueOf(alumno.getCodAlum()), String.valueOf(notaMedia));	
			resueltos = 0;
			numExam = 0;
			notaMedia = 0.0d;
		}
				
		
		notaMediaAsignatura = (double)Math.round((notaMediaAsignatura / alumnos.size())*100)/100;
		
		request.getSession().setAttribute("notasAlumnos", notasAlumnos);
		request.getSession().setAttribute("alumnos", alumnos);		
		request.getSession().setAttribute("notaMediaAsignatura", notaMediaAsignatura);		
		request.getSession().setAttribute("numExamenesResueltos", numExamenesResueltos);
		request.getSession().setAttribute("numExamenesPropuestos", examenes.size());		
		request.getSession().setAttribute("asignatura", asignatura);		
		
		return mapping.findForward("verNotasAsignatura");
	}

	private ActionForward notasPorAlumno(ActionMapping mapping,
			ActionForm form, HttpServletRequest request,
			HttpServletResponse response) {

		Profesor profesor = (Profesor)request.getSession().getAttribute("usuario");
		
		NotaForm notaForm = (NotaForm)form;		
		
		AsignaturaDAO asignaturaDao = new AsignaturaDAO();
		AlumnoDAO alumnoDao = new AlumnoDAO();
		ExamenDAO examenDao = new ExamenDAO();
		ExamenResueltoDAO examenResueltoDao = new ExamenResueltoDAO();
		
		ExamenResuelto examenResuelto = new ExamenResuelto();
		Alumno alumno = new Alumno();
		
		String codAlum = notaForm.getCodAlum();
		
		if(codAlum != null && !"".equals(codAlum)){
			alumno = (Alumno)alumnoDao.findById(codAlum).get(0);	
		}
					
		List<Asignatura> asignaturas = asignaturaDao.findAsignaturasAlumno(alumno);
		
		double notaMedia = 0.0d;
		int numExam = 0;
		
		Map<String, String> notasMedias = new HashMap<String, String>();
		Map<String, Integer> numExamenesPropuestos = new HashMap<String, Integer>();
		Map<String, Integer> numExamenesResueltos = new HashMap<String, Integer>();
		
		List<Examen> examenes = new ArrayList<Examen>();
		List<ExamenResuelto> examenesResueltos = new ArrayList<ExamenResuelto>();	
		
		
		for (Iterator iterator = asignaturas.iterator(); iterator.hasNext();) {
			Asignatura asignatura = (Asignatura)iterator.next();
			
			examenes = (List<Examen>)examenDao.findByAsignatura(asignatura);
			
			/*
			 * examenes propuestos para la asignatura
			 */
			numExamenesPropuestos.put(String.valueOf(asignatura.getCodAsig()), examenes.size());
			
			if(examenes.size() > 0){
				for (Iterator iterator2 = examenes.iterator(); iterator2.hasNext();) {
					Examen examen = (Examen) iterator2.next();			
					if(examenResueltoDao.findByExamenYAlumno(examen, alumno).size() > 0){
						examenResuelto = (ExamenResuelto)examenResueltoDao.findByExamenYAlumno(examen,alumno).get(0);
						examenesResueltos.add(examenResuelto);
						notaMedia = examenResuelto.getNota() + notaMedia;
						numExam++;
					}			
				}
			}
			/*
			 * examenes resueltos de la asignatura
			 */
			numExamenesResueltos.put(String.valueOf(asignatura.getCodAsig()), numExam);
			
			if(numExam > 0){
				notaMedia = (double)Math.round((notaMedia / numExam)*100)/100;
				notasMedias.put(String.valueOf(asignatura.getCodAsig()), String.valueOf((notaMedia)));
				numExam = 0;
				notaMedia = 0.0d;
			}else{
				notasMedias.put(String.valueOf(asignatura.getCodAsig()), "0.0");				
			}
		}
		
		notaForm.setAsignaturas(asignaturas);
		
		request.getSession().setAttribute("alumno", alumno);
		request.getSession().setAttribute("asignaturas", asignaturas);
		request.getSession().setAttribute("notasMedias", notasMedias);
		request.getSession().setAttribute("numExamenesResueltos", numExamenesResueltos);
		request.getSession().setAttribute("numExamenesPropuestos", numExamenesPropuestos);
		
		return mapping.findForward("verNotasMediasAlumno");
	}

	private ActionForward listar(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response) {
		
		Profesor profesor = (Profesor)request.getSession().getAttribute("usuario");
		
		NotaForm notaForm = (NotaForm)form;
				
		AsignaturaDAO asignaturaDao = new AsignaturaDAO();
		AlumnoDAO alumnoDao = new AlumnoDAO();
				
		List<Asignatura> asignaturas = asignaturaDao.findAsignaturasProfesor(profesor);
		List<Alumno> alumnos = new ArrayList<Alumno>();
		List<Alumno> alumnosAsignatura = new ArrayList<Alumno>();
		
		for (Iterator iterator = asignaturas.iterator(); iterator.hasNext();) {
			Asignatura asignatura = (Asignatura) iterator.next();
			alumnosAsignatura = new ArrayList<Alumno>((Set<Alumno>)alumnoDao.findAlumnosAsignatura(asignatura));
			for (Iterator iterator2 = alumnosAsignatura.iterator(); iterator2
					.hasNext();) {
				Alumno alumno = (Alumno) iterator2.next();
				if(!alumnos.contains(alumno)){
					alumnos.add(alumno);					
				}
			}
		}
		
		notaForm.setAsignaturas(asignaturas);
		notaForm.setAlumnos(alumnos);
		
		request.getSession().setAttribute("asignaturas", asignaturas);
		request.getSession().setAttribute("alumnos", alumnos);
		
		return mapping.findForward("opcionesNotas");
	}
	
}
